home *** CD-ROM | disk | FTP | other *** search
/ CICA 1995 September (Japanese) / CICA Shareware for Windows CD-ROM (Walnut Creek) (September 1995) (Japanese) (Disc 2).iso / disc2 / nt / ntperf.exe / PERFTOOLS / SRC / PERFMON / COUNTERS.C_ / COUNTERS.C
Encoding:
C/C++ Source or Header  |  1993-05-15  |  25.7 KB  |  938 lines
  1. /*++ BUILD Version: 0001    // Increment this if a change has global effects
  2.  
  3. Copyright (c) 1992-1993   Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     counters.c  
  8.  
  9. Abstract:
  10.  
  11.     This module contains the routines to calculate "DataPoint" values from
  12.     the registry data.
  13.  
  14.     The algoritms were lifted from RussBls's "Data.C" in winmeter.
  15.  
  16.     All the math is done in floating point to get the correct results, at
  17.     the sacrifice of efficiency on a 386 with not 387. We can always
  18.     revisit these routines later.
  19.  
  20. Revision History:
  21.  
  22.     Bob Watson  11/04/92
  23.         -- modified calculations to use more integer math and "early
  24.             exits" to improve efficiency on slower & non-coprocessor
  25.             machines
  26. --*/
  27.  
  28. //==========================================================================//
  29. //                                  Includes                                //
  30. //==========================================================================//
  31.  
  32.  
  33. #include "perfmon.h"       // perfmon include files
  34. #include "counters.h"      // Exported declarations for this file
  35.  
  36.  
  37. //==========================================================================//
  38. //                                  Constants                               //
  39. //==========================================================================//
  40.  
  41.  
  42. #define INVERT             PERF_COUNTER_TIMER_INV
  43. #define NS100_INVERT       PERF_100NSEC_TIMER_INV
  44. #define NS100              PERF_100NSEC_TIMER
  45. #define TIMER_MULTI        PERF_COUNTER_MULTI_TIMER
  46. #define TIMER_MULTI_INVERT PERF_COUNTER_MULTI_TIMER_INV
  47. #define NS100_MULTI        PERF_100NSEC_MULTI_TIMER
  48. #define NS100_MULTI_INVERT PERF_100NSEC_MULTI_TIMER_INV
  49.  
  50.  
  51. #define FRACTION 1
  52. #define BULK     1
  53.  
  54.  
  55. //==========================================================================//
  56. //                              Local Functions                             //
  57. //==========================================================================//
  58.  
  59.  
  60. #define LargeIntegerLessThanOrEqualZero(X) (\
  61.     (X).HighPart < 0 ? TRUE : \
  62.     ((X).HighPart == 0) && ((X).LowPart == 0) ? TRUE : \
  63.     FALSE)
  64.  
  65.  
  66. FLOAT
  67. eLIntToFloat(
  68.     IN PLARGE_INTEGER pLargeInt
  69. )
  70. /*++
  71.  
  72. Routine Description:
  73.  
  74.     Converts a large integer to a floating point number
  75.  
  76. Arguments:
  77.  
  78.     IN pLargeInt    Pointer to large integer to return as a floating point
  79.                     number.
  80.  
  81. Return Value:
  82.  
  83.     Floating point representation of Large Integer passed in arg. list
  84. --*/
  85. {
  86.     FLOAT   eSum;
  87.  
  88.     if (pLargeInt->HighPart == 0) {
  89.         return (FLOAT) pLargeInt->LowPart;
  90.     } else {
  91.  
  92.         // Scale the high portion so it's value is in the upper 32 bit
  93.         // range.  Then add it to the low portion.
  94.  
  95.         eSum = (FLOAT) pLargeInt->HighPart * 4.294967296E9f ;
  96.         eSum += (FLOAT) pLargeInt->LowPart  ;
  97.  
  98.         return (eSum) ;
  99.     }
  100. } //eLIntToFloat
  101.  
  102. FLOAT
  103. eGetTimeInterval(
  104.     IN PLARGE_INTEGER pliCurrentTime,
  105.     IN PLARGE_INTEGER pliPreviousTime,
  106.     IN PLARGE_INTEGER pliFreq
  107. )
  108. /*++
  109.  
  110. Routine Description:
  111.  
  112.     Get the difference between the current and previous time counts,
  113.         then divide by the frequency.
  114.     
  115. Arguments:
  116.  
  117.     IN pCurrentTime
  118.     IN pPreviousTime
  119.         used to compute the duration of this sample (the time between
  120.         samples
  121.  
  122.     IN pliFreq
  123.         # of  counts (clock ticks) per second
  124.  
  125. Return Value:
  126.  
  127.     Floating point representation of Time Interval (seconds)
  128. --*/
  129. {
  130.     FLOAT   eTimeDifference;
  131.     FLOAT   eFreq;
  132.     FLOAT   eTimeInterval ;
  133.  
  134.     LARGE_INTEGER liDifference;
  135.  
  136.     // Get the number of counts that have occured since the last sample
  137.  
  138.     liDifference = LargeIntegerSubtract (
  139.             *pliCurrentTime,
  140.             *pliPreviousTime);
  141.  
  142.     if (LargeIntegerLessThanOrEqualZero(liDifference)) {
  143.         return (FLOAT) 0.0f;
  144.     } else {
  145.         eTimeDifference = eLIntToFloat(&liDifference);
  146.  
  147.         // Get the counts per second
  148.  
  149.         eFreq = eLIntToFloat(pliFreq) ;
  150.  
  151.         // Get the time since the last sample.
  152.  
  153.         eTimeInterval = eTimeDifference / eFreq ;
  154.  
  155.         return (eTimeInterval) ;
  156.     }
  157. } // eGetTimeInterval
  158.  
  159. FLOAT
  160. Counter_Counter_Common(
  161.     IN PLINESTRUCT pLineStruct,
  162.     IN INT iType
  163. )
  164. /*++
  165.  
  166. Routine Description:
  167.  
  168.     Take the difference between the current and previous counts
  169.         then divide by the time interval
  170.     
  171. Arguments:
  172.  
  173.     IN pLineStruct
  174.         Line structure containing data to perform computations on
  175.  
  176.     IN iType
  177.         Counter Type
  178.         
  179.  
  180. Return Value:
  181.  
  182.     Floating point representation of outcome
  183. --*/
  184. {
  185.     FLOAT   eTimeInterval;
  186.     FLOAT   eDifference;
  187.     FLOAT   eCount ;
  188.  
  189.     LARGE_INTEGER   liDifference;
  190.  
  191.     if (iType != BULK) {
  192.         liDifference.HighPart = 0;
  193.         liDifference.LowPart = pLineStruct->lnaCounterValue[0].LowPart -
  194.                             pLineStruct->lnaOldCounterValue[0].LowPart;
  195.     } else {
  196.         liDifference = LargeIntegerSubtract (
  197.                         pLineStruct->lnaCounterValue[0],
  198.                         pLineStruct->lnaOldCounterValue[0]);
  199.     }
  200.     
  201.     if (LargeIntegerLessThanOrEqualZero(liDifference)) {
  202.         return (FLOAT) 0.0f;
  203.     } else {
  204.         eTimeInterval = eGetTimeInterval(&pLineStruct->lnNewTime,
  205.                                         &pLineStruct->lnOldTime,
  206.                                         &pLineStruct->lnPerfFreq) ;
  207.         if (eTimeInterval <= 0.0f) {
  208.             return (FLOAT) 0.0f;
  209.         } else {
  210.             eDifference = eLIntToFloat (&liDifference);
  211.  
  212.             eCount         = eDifference / eTimeInterval ;
  213.  
  214.             return(eCount) ;
  215.         }
  216.     }
  217. } // Counter_Counter_Common
  218.  
  219.  
  220. FLOAT
  221. Counter_Average_Timer(
  222.     IN PLINESTRUCT pLineStruct
  223. )
  224. /*++
  225.  
  226. Routine Description:
  227.  
  228.     Take the differences between the current and previous times and counts
  229.     divide the time interval by the counts multiply by 10,000,000 (convert
  230.     from 100 nsec to sec)
  231.     
  232. Arguments:
  233.  
  234.     IN pLineStruct
  235.         Line structure containing data to perform computations on
  236.  
  237. Return Value:
  238.  
  239.     Floating point representation of outcome
  240. --*/
  241. {
  242.     FLOAT   eTimeInterval;
  243.     FLOAT   eCount;
  244.  
  245.     LARGE_INTEGER    liDifference;
  246.  
  247.     // Get the current and previous counts.
  248.  
  249.     liDifference.HighPart = 0;
  250.     liDifference.LowPart = pLineStruct->lnaCounterValue[1].LowPart - 
  251.             pLineStruct->lnaOldCounterValue[1].LowPart;
  252.  
  253.     if ( LargeIntegerLessThanOrEqualZero(liDifference)) {
  254.         return (FLOAT) 0.0f;
  255.     } else {
  256.         // Get the amount of time that has passed since the last sample
  257.         eTimeInterval = eGetTimeInterval(&pLineStruct->lnaCounterValue[0],
  258.                                             &pLineStruct->lnaOldCounterValue[0],
  259.                                             &pLineStruct->lnPerfFreq) ;
  260.  
  261.         if (eTimeInterval < 0.0f) { // return 0 if negative time has passed
  262.             return (0.0f);
  263.         } else {
  264.             // Get the number of counts in this time interval.
  265.             eCount = eTimeInterval / eLIntToFloat (&liDifference);
  266.             return(eCount) ;
  267.         }
  268.     }
  269. } //Counter_Average_Timer
  270.  
  271.  
  272.  
  273. FLOAT
  274. Counter_Average_Bulk(
  275.     IN PLINESTRUCT pLineStruct
  276. )
  277. /*++
  278.  
  279. Routine Description:
  280.  
  281.     Take the differences between the current and previous byte counts and
  282.     operation counts divide the bulk count by the operation counts
  283.     
  284. Arguments:
  285.  
  286.     IN pLineStruct
  287.         Line structure containing data to perform computations on
  288.  
  289. Return Value:
  290.  
  291.     Floating point representation of outcome
  292. --*/
  293. {
  294.     FLOAT   eBulkDelta;
  295.     FLOAT   eDifference;
  296.     FLOAT   eCount;
  297.  
  298.     LARGE_INTEGER liDifference;
  299.     LARGE_INTEGER liBulkDelta;
  300.  
  301.     // Get the bulk count increment since the last sample
  302.  
  303.     liBulkDelta = LargeIntegerSubtract(
  304.             pLineStruct->lnaCounterValue[0],
  305.             pLineStruct->lnaOldCounterValue[0]);
  306.  
  307.     if (LargeIntegerLessThanOrEqualZero(liBulkDelta)) {
  308.         return (FLOAT) 0.0f;
  309.     } else {
  310.         // Get the current and previous counts.
  311.         liDifference.HighPart = 0;
  312.         liDifference.LowPart = pLineStruct->lnaCounterValue[1].LowPart -
  313.                 pLineStruct->lnaOldCounterValue[1].LowPart;
  314.  
  315.         // Get the number of counts in this time interval.
  316.  
  317.         if ( LargeIntegerLessThanOrEqualZero(liDifference)) {
  318.             // Counter value invalid
  319.             return (FLOAT) 0.0f;
  320.         } else {
  321.             eBulkDelta = eLIntToFloat (&liBulkDelta);
  322.             eDifference = eLIntToFloat (&liDifference);
  323.             eCount = eBulkDelta / eDifference ;
  324.  
  325.             // Scale the value to up to 1 second
  326.  
  327.             return(eCount) ;
  328.         }
  329.     }
  330. } // Counter_Average_Bulk
  331.  
  332.  
  333.  
  334. FLOAT
  335. Counter_Timer_Common(
  336.     IN  PLINESTRUCT pLineStruct,
  337.     IN  INT iType
  338. )
  339. /*++
  340.  
  341. Routine Description:
  342.  
  343.     Take the difference between the current and previous counts,
  344.         Normalize the count (counts per interval)
  345.         divide by the time interval (count = % of interval)
  346.         if (invert)
  347.             subtract from 1 (the normalized size of an interval)
  348.         multiply by 100 (convert to a percentage)
  349.         this value from 100.
  350.     
  351. Arguments:
  352.  
  353.     IN pLineStruct
  354.         Line structure containing data to perform computations on
  355.  
  356.     IN iType
  357.         Counter Type
  358.  
  359. Return Value:
  360.  
  361.     Floating point representation of outcome
  362. --*/
  363. {
  364.     FLOAT   eTimeInterval;
  365.     FLOAT   eDifference;
  366.     FLOAT   eFreq;
  367.     FLOAT   eFraction;
  368.     FLOAT   eMultiBase;
  369.     FLOAT   eCount ;
  370.  
  371.     LARGE_INTEGER   liTimeInterval;
  372.     LARGE_INTEGER   liDifference;
  373.  
  374.     // Get the amount of time that has passed since the last sample
  375.  
  376.     if (iType == NS100 ||
  377.         iType == NS100_INVERT ||
  378.         iType == NS100_MULTI ||
  379.         iType == NS100_MULTI_INVERT) {
  380.             liTimeInterval = LargeIntegerSubtract (
  381.                 pLineStruct->lnNewTime100Ns,
  382.                 pLineStruct->lnOldTime100Ns) ;
  383.             eTimeInterval = eLIntToFloat (&liTimeInterval);
  384.     } else {
  385.             eTimeInterval = eGetTimeInterval(&pLineStruct->lnNewTime,
  386.                                             &pLineStruct->lnOldTime,
  387.                                             &pLineStruct->lnPerfFreq) ;
  388.     }
  389.  
  390.     // Get the current and previous counts.
  391.  
  392.     liDifference = LargeIntegerSubtract (
  393.             pLineStruct->lnaCounterValue[0],
  394.             pLineStruct->lnaOldCounterValue[0]) ;
  395.  
  396.     // Get the number of counts in this time interval.
  397.     // (1, 2, 3 or any number of seconds could have gone by since
  398.     // the last sample)
  399.  
  400.     eDifference = eLIntToFloat (&liDifference) ;
  401.  
  402.     if (iType == 0 || iType == INVERT)
  403.     {
  404.         // Get the counts per interval (second)
  405.  
  406.         eFreq = eLIntToFloat(&pLineStruct->lnPerfFreq) ;
  407.  
  408.         // Calculate the fraction of the counts that are used by whatever
  409.         // we are measuring
  410.  
  411.         eFraction = eDifference / eFreq ;
  412.     }
  413.     else
  414.     {
  415.         eFraction = eDifference ;
  416.     }
  417.  
  418.     // Calculate the fraction of time used by what were measuring.
  419.  
  420.     eCount = eFraction / eTimeInterval ;
  421.  
  422.     // If this is  an inverted count take care of the inversion.
  423.  
  424.     if (iType == INVERT || iType == NS100_INVERT)
  425.         eCount = (FLOAT) 1.0 - eCount ;
  426.  
  427.     // If this is  an inverted multi count take care of the inversion.
  428.  
  429.     if (iType == TIMER_MULTI_INVERT || iType == NS100_MULTI_INVERT) {
  430.         eMultiBase  = (FLOAT)pLineStruct->lnaCounterValue[1].LowPart ;
  431.         eCount = (FLOAT) eMultiBase - eCount ;
  432.     }
  433.  
  434.     // Scale the value to up to 100.
  435.  
  436.     eCount *= 100.0f ;
  437.  
  438.     if (eCount < 0.0f) eCount = 0.0f ;
  439.  
  440.     if (eCount > 100.0f &&
  441.         iType != NS100_MULTI &&
  442.         iType != NS100_MULTI_INVERT &&
  443.         iType != TIMER_MULTI &&
  444.         iType != TIMER_MULTI_INVERT) {
  445.  
  446.         eCount = 100.0f;
  447.     }
  448.  
  449.     return(eCount) ;
  450. } // Counter_Timer_Common
  451.  
  452.  
  453. FLOAT
  454. Counter_Raw_Fraction(
  455.     IN PLINESTRUCT pLineStruct
  456. )
  457. /*++
  458.  
  459. Routine Description:
  460.  
  461.     Evaluate a raw fraction (no time, just two values: Numerator and
  462.         Denominator) and multiply by 100 (to make a percentage;
  463.  
  464. Arguments:
  465.  
  466.     IN pLineStruct
  467.         Line structure containing data to perform computations on
  468.  
  469. Return Value:
  470.  
  471.     Floating point representation of outcome
  472. --*/
  473. {
  474.     FLOAT   eCount ;
  475.  
  476.     LARGE_INTEGER   liNumerator;
  477.  
  478.     if ( pLineStruct->lnaCounterValue[0].LowPart == 0 ||
  479.             pLineStruct->lnaCounterValue[1].LowPart == 0 ) {
  480.         // invalid value
  481.         return (0.0f);
  482.     } else {
  483.         liNumerator = EnlargedIntegerMultiply (
  484.                 pLineStruct->lnaCounterValue[0].LowPart,
  485.                 100L);
  486.         eCount = eLIntToFloat(&liNumerator)  /
  487.                  (FLOAT) pLineStruct->lnaCounterValue[1].LowPart;
  488.         return(eCount) ;
  489.     }
  490. } // Counter_Raw_Fraction
  491.  
  492.  
  493. FLOAT
  494. eElapsedTime(
  495.     PLINESTRUCT pLineStruct,
  496.     INT iType
  497. )
  498. /*++
  499.  
  500. Routine Description:
  501.  
  502.     Converts 100NS elapsed time to fractional seconds
  503.  
  504. Arguments:
  505.  
  506.     IN pLineStruct
  507.         Line structure containing data to perform computations on
  508.  
  509.     IN iType
  510.         Unused.
  511.  
  512. Return Value:
  513.  
  514.     Floating point representation of elapsed time in seconds
  515. --*/
  516. {
  517.     FLOAT   eSeconds ;
  518.  
  519.     LARGE_INTEGER   liDifference;
  520.  
  521.     if (LargeIntegerLessThanOrEqualZero(pLineStruct->lnaCounterValue[0] )) {
  522.         // no data [start time = 0] so return 0
  523.         return (FLOAT) 0.0f;
  524.     } else {
  525.         // otherwise compute difference between current time and start time
  526.         liDifference = LargeIntegerSubtract (
  527.             pLineStruct->lnNewTime,             // sample time in obj. units
  528.             pLineStruct->lnaCounterValue[0]);   // start time in obj. units
  529.  
  530.         if (LargeIntegerLessThanOrEqualZero(liDifference)) {
  531.             return (FLOAT) 0.0f;
  532.         } else {
  533.             // convert to fractional seconds using object counter
  534.             eSeconds = eLIntToFloat (&liDifference) /
  535.                 eLIntToFloat (&pLineStruct->lnObject.PerfFreq);
  536.  
  537.             return (eSeconds);
  538.         }
  539.     }
  540.     
  541. } // eElapsedTime
  542.  
  543.  
  544. FLOAT
  545. Sample_Common(
  546.     PLINESTRUCT pLineStruct,
  547.     INT iType
  548. )
  549. /*++
  550.  
  551. Routine Description:
  552.  
  553.     Divites "Top" differenced by Base Difference
  554.  
  555. Arguments:
  556.  
  557.     IN pLineStruct
  558.         Line structure containing data to perform computations on
  559.  
  560.     IN iType
  561.         Counter Type
  562.  
  563. Return Value:
  564.  
  565.     Floating point representation of outcome
  566. --*/
  567. {
  568.     FLOAT   eCount ;
  569.  
  570.     LONG    lDifference;
  571.     LONG    lBaseDifference;
  572.  
  573.     lDifference = pLineStruct->lnaCounterValue[0].LowPart -
  574.         pLineStruct->lnaOldCounterValue[0].LowPart ;
  575.  
  576.     if (lDifference <= 0) {
  577.         return (FLOAT) 0.0f;
  578.     } else {
  579.         lBaseDifference = pLineStruct->lnaCounterValue[1].LowPart -
  580.             pLineStruct->lnaOldCounterValue[1].LowPart ;
  581.  
  582.         if ( lBaseDifference <= 0 ) {
  583.             // invalid value
  584.             return (0.0f);
  585.         } else {
  586.             eCount = (FLOAT)lDifference / (FLOAT)lBaseDifference ;
  587.  
  588.             if (iType == FRACTION) {
  589.                 eCount *= (FLOAT) 100.0f ;
  590.             }
  591.             return(eCount) ;
  592.         }
  593.     }
  594. } // Sample_Common
  595.  
  596.  
  597. //==========================================================================//
  598. //                             Exported Functions                           //
  599. //==========================================================================//
  600.  
  601.  
  602. /*****************************************************************************
  603.  * Counter_Counter - Take the difference between the current and previous
  604.  *                   counts then divide by the time interval
  605.  ****************************************************************************/
  606. #define Counter_Counter(pLineStruct)      \
  607.         Counter_Counter_Common(pLineStruct, 0)
  608. #if 0
  609. FLOAT Counter_Counter(PLINESTRUCT pLineStruct)
  610. {
  611.         return Counter_Counter_Common(pLineStruct, 0) ;
  612. }
  613. #endif
  614.  
  615. /*****************************************************************************
  616.  * Counter_Bulk    - Take the difference between the current and previous
  617.  *                   counts then divide by the time interval
  618.  *                   Same as a Counter_counter except it uses large_ints
  619.  ****************************************************************************/
  620. #define Counter_Bulk(pLineStruct)         \
  621.         Counter_Counter_Common(pLineStruct, BULK)
  622. #if 0
  623. FLOAT Counter_Bulk(PLINESTRUCT pLineStruct)
  624. {
  625.         return Counter_Counter_Common(pLineStruct, BULK) ;
  626. }
  627. #endif
  628.  
  629.  
  630. /*****************************************************************************
  631.  * Counter_Timer100Ns -
  632.  *
  633.  ****************************************************************************/
  634. #define Counter_Timer100Ns(pLineStruct)     \
  635.         Counter_Timer_Common(pLineStruct, NS100)
  636. #if 0
  637. FLOAT Counter_Timer100Ns(PLINESTRUCT pLineStruct)
  638. {
  639.         return Counter_Timer_Common(pLineStruct, NS100) ;
  640. }
  641. #endif
  642.  
  643. /*****************************************************************************
  644.  * Counter_Timer100Ns_Inv -
  645.  *
  646.  ****************************************************************************/
  647. #define Counter_Timer100Ns_Inv(pLineStruct)     \
  648.         Counter_Timer_Common(pLineStruct, NS100_INVERT)
  649. #if 0
  650. FLOAT Counter_Timer100Ns_Inv(PLINESTRUCT pLineStruct)
  651. {
  652.         return Counter_Timer_Common(pLineStruct, NS100_INVERT) ;
  653.  
  654. }
  655. #endif
  656.  
  657. /*****************************************************************************
  658.  * Counter_Timer_Multi -
  659.  *
  660.  ****************************************************************************/
  661. #define Counter_Timer_Multi(pLineStruct)     \
  662.         Counter_Timer_Common(pLineStruct, TIMER_MULTI)
  663. #if 0
  664. FLOAT Counter_Timer_Multi(PLINESTRUCT pLineStruct)
  665. {
  666.         return Counter_Timer_Common(pLineStruct, TIMER_MULTI) ;
  667. }
  668. #endif
  669.  
  670. /*****************************************************************************
  671.  * Counter_Timer_Multi_Inv -
  672.  *
  673.  ****************************************************************************/
  674. #define Counter_Timer_Multi_Inv(pLineStruct)       \
  675.         Counter_Timer_Common(pLineStruct, TIMER_MULTI_INVERT)
  676. #if 0
  677. FLOAT Counter_Timer_Multi_Inv(PLINESTRUCT pLineStruct)
  678. {
  679.         return Counter_Timer_Common(pLineStruct, TIMER_MULTI_INVERT) ;
  680. }
  681. #endif
  682.  
  683.  
  684. /*****************************************************************************
  685.  * Counter_Timer100Ns_Multi -
  686.  *
  687.  ****************************************************************************/
  688. #define Counter_Timer100Ns_Multi(pLineStruct)     \
  689.         Counter_Timer_Common(pLineStruct, NS100_MULTI)
  690. #if 0
  691. FLOAT Counter_Timer100Ns_Multi(PLINESTRUCT pLineStruct)
  692. {
  693.         return Counter_Timer_Common(pLineStruct, NS100_MULTI) ;
  694. }
  695. #endif
  696.  
  697. /*****************************************************************************
  698.  * Counter_Timer100Ns_Multi_Inv -
  699.  *
  700.  ****************************************************************************/
  701. #define Counter_Timer100Ns_Multi_Inv(pLineStruct)    \
  702.         Counter_Timer_Common(pLineStruct, NS100_MULTI_INVERT)
  703. #if 0
  704. FLOAT Counter_Timer100Ns_Multi_Inv(PLINESTRUCT pLineStruct)
  705. {
  706.         return Counter_Timer_Common(pLineStruct, NS100_MULTI_INVERT) ;
  707. }
  708. #endif
  709.  
  710. /*****************************************************************************
  711.  * Counter_Timer - Take the difference between the current and previous
  712.  *                 counts,
  713.  *                 Normalize the count (counts per interval)
  714.  *                 divide by the time interval (count = % of interval)
  715.  *                 multiply by 100 (convert to a percentage)
  716.  *                 this value from 100.
  717.  ****************************************************************************/
  718. #define Counter_Timer(pLineStruct)       \
  719.         Counter_Timer_Common(pLineStruct, 0)
  720. #if 0
  721. FLOAT Counter_Timer(PLINESTRUCT pLineStruct)
  722. {
  723.         return Counter_Timer_Common(pLineStruct, 0) ;
  724. }
  725. #endif
  726.  
  727.  
  728. /*****************************************************************************
  729.  * Counter_Timer_Inv - Take the difference between the current and previous
  730.  *                     counts,
  731.  *                     Normalize the count (counts per interval)
  732.  *                     divide by the time interval (count = % of interval)
  733.  *                     subtract from 1 (the normalized size of an interval)
  734.  *                     multiply by 100 (convert to a percentage)
  735.  *                     this value from 100.
  736.  ****************************************************************************/
  737. #define Counter_Timer_Inv(pLineStruct)         \
  738.       Counter_Timer_Common(pLineStruct, INVERT)
  739. #if 0
  740. FLOAT Counter_Timer_Inv(PLINESTRUCT pLineStruct)
  741. {
  742.         return Counter_Timer_Common(pLineStruct, INVERT) ;
  743. }
  744. #endif
  745.  
  746. /*****************************************************************************
  747.  * Sample_Counter -
  748.  ****************************************************************************/
  749. #define Sample_Counter(pLineStruct)      \
  750.       Sample_Common(pLineStruct, 0)
  751. #if 0
  752. FLOAT Sample_Counter(PLINESTRUCT pLineStruct)
  753. {
  754.         return Sample_Common(pLineStruct, 0) ;
  755. }
  756. #endif
  757.  
  758. /*****************************************************************************
  759.  * Sample_Fraction -
  760.  ****************************************************************************/
  761. #define Sample_Fraction(pLineStruct)     \
  762.      Sample_Common(pLineStruct, FRACTION)
  763. #if 0
  764. FLOAT Sample_Fraction(PLINESTRUCT pLineStruct)
  765. {
  766.         return Sample_Common(pLineStruct, FRACTION) ;
  767. }
  768. #endif
  769.  
  770. /*****************************************************************************
  771.  * Counter_Rawcount - This is just a raw count.
  772.  ****************************************************************************/
  773. #define Counter_Rawcount(pLineStruct)     \
  774.    ((FLOAT) (pLineStruct->lnaCounterValue[0].LowPart))
  775. #if 0
  776. FLOAT Counter_Rawcount(PLINESTRUCT pLineStruct)
  777.    {
  778.    return((FLOAT) (pLineStruct->lnaCounterValue[0].LowPart)) ;
  779.    }
  780. #endif
  781.  
  782. /*****************************************************************************
  783.  * Counter_Null - The counters that return nothing go here.
  784.  ****************************************************************************/
  785. #define Counter_Elapsed_Time(pLineStruct)         \
  786.     eElapsedTime (pLineStruct, 0)
  787. #if 0
  788. FLOAT Counter_Elapsed_Time (PLINESTRUCT pLineStruct)
  789. {
  790.     return eElapsedTime (pLineStruct, 0);
  791. }
  792. #endif
  793.  
  794. /*****************************************************************************
  795.  * Counter_Null - The counters that return nothing go here.
  796.  ****************************************************************************/
  797. #define Counter_Null(pline)        \
  798.         ((FLOAT) 0.0)
  799. #if 0
  800. FLOAT Counter_Null(PLINESTRUCT pline)
  801. {
  802.         return((FLOAT) 0.0);
  803.         pline;
  804. }
  805. #endif
  806.  
  807.  
  808. FLOAT
  809. CounterEntry (
  810.     PLINESTRUCT pLine
  811. )
  812. {
  813.     switch (pLine->lnCounterType) {
  814.         case  PERF_COUNTER_COUNTER:
  815.             return Counter_Counter (pLine);
  816.  
  817.         case  PERF_COUNTER_TIMER:
  818.             return Counter_Timer (pLine);
  819.  
  820.         case  PERF_COUNTER_QUEUELEN_TYPE:
  821.             return Counter_Queuelen(pLine);
  822.  
  823.         case  PERF_COUNTER_BULK_COUNT:
  824.             return Counter_Bulk (pLine);
  825.  
  826.         case  PERF_COUNTER_TEXT:
  827.             return Counter_Null (pLine);
  828.  
  829.         case  PERF_COUNTER_RAWCOUNT:
  830.             return Counter_Rawcount(pLine);
  831.  
  832.         case  PERF_SAMPLE_FRACTION:
  833.             return Sample_Fraction(pLine);
  834.  
  835.         case  PERF_SAMPLE_COUNTER:
  836.             return Sample_Counter (pLine);
  837.  
  838.         case  PERF_COUNTER_NODATA:
  839.             return Counter_Null (pLine);
  840.  
  841.         case  PERF_COUNTER_TIMER_INV:
  842.             return Counter_Timer_Inv (pLine);
  843.  
  844.         case  PERF_RAW_BASE:
  845.             return Counter_Null (pLine);
  846.  
  847.         case  PERF_AVERAGE_TIMER:
  848.             return Counter_Average_Timer (pLine);
  849.  
  850.         case  PERF_AVERAGE_BULK:
  851.             return Counter_Average_Bulk (pLine);
  852.  
  853.         case  PERF_100NSEC_TIMER:
  854.             return Counter_Timer100Ns (pLine);
  855.  
  856.         case  PERF_100NSEC_TIMER_INV:
  857.             return Counter_Timer100Ns_Inv (pLine);
  858.  
  859.         case  PERF_COUNTER_MULTI_TIMER:
  860.             return Counter_Timer_Multi (pLine);
  861.  
  862.         case  PERF_COUNTER_MULTI_TIMER_INV:
  863.             return Counter_Timer_Multi_Inv (pLine);
  864.  
  865.         case  PERF_COUNTER_MULTI_BASE:
  866.             return Counter_Null (pLine);
  867.  
  868.         case  PERF_100NSEC_MULTI_TIMER:
  869.             return Counter_Timer100Ns_Multi (pLine);
  870.                  
  871.         case  PERF_100NSEC_MULTI_TIMER_INV:
  872.             return Counter_Timer100Ns_Multi_Inv (pLine);
  873.  
  874.         case  PERF_RAW_FRACTION:
  875.             return Counter_Raw_Fraction (pLine);
  876.  
  877.         case  PERF_ELAPSED_TIME:
  878.             return Counter_Elapsed_Time (pLine);
  879.            
  880.         default:
  881.             return Counter_Null (pLine);
  882.  
  883.     }
  884. }
  885.  
  886.  
  887. BOOL
  888. IsCounterSupported (
  889.     DWORD dwCounterType
  890. )
  891. {
  892.     switch (dwCounterType) {
  893. // supported counters
  894.         case  PERF_COUNTER_COUNTER:
  895.         case  PERF_COUNTER_TIMER:
  896.         case  PERF_COUNTER_QUEUELEN_TYPE:
  897.         case  PERF_COUNTER_BULK_COUNT:
  898.         case  PERF_COUNTER_RAWCOUNT:
  899.         case  PERF_SAMPLE_FRACTION:
  900.         case  PERF_SAMPLE_COUNTER:
  901.         case  PERF_COUNTER_TIMER_INV:
  902.         case  PERF_AVERAGE_TIMER:
  903.         case  PERF_AVERAGE_BULK:
  904.         case  PERF_100NSEC_TIMER:
  905.         case  PERF_100NSEC_TIMER_INV:
  906.         case  PERF_COUNTER_MULTI_TIMER:
  907.         case  PERF_COUNTER_MULTI_TIMER_INV:
  908.         case  PERF_100NSEC_MULTI_TIMER:
  909.         case  PERF_100NSEC_MULTI_TIMER_INV:
  910.         case  PERF_RAW_FRACTION:
  911.         case  PERF_ELAPSED_TIME:
  912.             return TRUE;
  913.  
  914. // unsupported counters
  915.         case  PERF_COUNTER_TEXT:
  916.         case  PERF_COUNTER_NODATA:
  917.         case  PERF_RAW_BASE:
  918.         case  PERF_COUNTER_MULTI_BASE:
  919.         default:
  920.             return FALSE;
  921.  
  922.     }
  923. }
  924.  
  925.  
  926.  
  927.  
  928.  
  929.  
  930.  
  931.  
  932.  
  933.  
  934.  
  935.  
  936.  
  937.  
  938.